{
// var num1 = 123;
// var num2 = 456;
// var a = num2;
// console.log('1',num1,num2)
// num2 = num1;
// num1 = a;
// console.log('2',num1,num2)

// var a = 123;
// var b = 456;
// var sum;
// b += 123;
// console.log(a)

// var b1 = 89;
// var b2 = 24;
// var b3 = b1 / b2;
// var b4 = b1 % b2;
// document.write('共耗时' + parseInt(b3) + '天' + b4 + '小时');



// {
// var ming = null;

//     ming = {
//         age:18,
//         mar:24,
//         max:'male'
//     }
//     console.log(ming.age)
// }
}
{//两种特殊数据类型：
    //五种基础数据类型：数字，字符，undefined，布尔值，null
}

{//逻辑运算符
     //console.log(parseInt('123546asdd'))
 }
 
 {//数字类型转换 .number
{
        // var num = '123';
        // console.log(Number(num));
 }
{//字符串转换
        // var num = 89;
        // var num1 = 89/24;
        // console.log(num1.toFixed(3));//保留小数点后几位
        // console.log(num.toString(9));//转换为几进制
        // console.log(String(num));//转换为字符串
        // console.log(num);
} 
{//布尔值转换
        //boolean()
}
}

{//变量类型
        //null,undefined,'',0,NaN转布尔值为false
    
        //其他都是ture
        // toString,toFixed,Number:都是变量名.number用法
        // 五种变量，只有undefined无法使用.number...用法
        //undefined和null都无法使用.用法
        {//undefind VS null
            //null  是 JS 设计缺陷
            //var num; undefind
            //typeof null -> 'object'
            
            //undefind 是我们 不会 主动写出来的，只会出现再 var num ，没有给num赋值的时候
            //null 什么时候会出现
            //1. var obj = null； 将来再给 obj 赋值，可以先赋值null
            //2. var n = '12345' -> 释放内存    n = null -> 释放n本来的内存空间
        }
        
        // var num;
        // console.log(num)
    }
    
{//隐式转换     逻辑运算，是执行 布尔判断，但是如果值不是布尔值的话，会进行隐式转换
        //他的返回值就是逻辑运算符 停止运算的那个位置的值
        // console.log((3 || 0) && 0); //-> 返回值：0
        // console.log(3 || 0 && 0);// -> 返回值：3
    //总结：逻辑运算符 -> 与和或 ，执行的时候都会隐式转换，目的是为了运算符的执行
    //er逻辑运算符的返回值是：表达式本身的值
    // console.log('asd' && true && 0);
    // console.log(Number('asd'));
    // console.log(Number(true));
    // console.log(Number(false));
// console.log(false || 0);
}

{//switch if
//条件分支：if else if
//作用：判断某些代码块是否执行

/* var tony = {
    age:15,
    name:tony,
}
if(tony.age >= 18){
    console.log('成年了');
}

if(tony.age >= 18){
    console.log('成年了');
}else{
    console.log('未成年');
}

if(tony.age < 16 && tony.age >= 0){
    console.log('111')
}else if(tony.age >=16 && tony.age <18){
    console.log('sda');
}else{
    console.log('ssda');
} */

//switch

/*     switch (变量){
        case 值:
            表达式;
            break;
        case 值:
            表达式;
            break;
        case 值:
            表达式;
            break;
        default:(默认值)
            表达式;
    } */

    //总结：switch 的执行逻辑：
        //判断switch（vaiable） -> vaiable 值等于哪个case，
        //就开始执行他小面的代码，
        //知道遇到break，才停止运行
    
    //switch 当中的default 等于if当中的else


//switch 与 if...if else() 有什么区别

    //switch 的关键特性：是拿 key === value;严格判断 key 是不是等于value
    // key === value的时候，则执行这个case 下面代码，直到遇到break

    //if...if else if()关键特性：
    // 特性1：表达式: 可以是 a > b， 也可以是 (1 < a) && (a < 10)
    // 特性2：expression 的返回值为 "true",  就执行 自己的 { 代码块 }， 不执行后面的代码，
    // 而 switch 是遇到  break 才停止执行
    // 表达式是 'aa' 也为 “true” 真
}

{//循环

    {//while
        // while(布尔表达式){
        // }
        // var num = 0
        // while(num == 0){
        //     console.log(num)
        // }

        // var num = 0
        // while(num <= 9){
        //     console.log(num)
        //     num++
        // }
        
        //总结：while 执行顺序：1 232323...2 知道2的表达是为 假
        //1.声明一个初始变量 2.左布尔表达式 3.执行代码块
        
        //打印100以内3的倍数
        // var num = 3
        // while(num < 100){
        //     if(num % 3 === 0){
        //         console.log(num)
        //     }
        //     num++
        // }
        // var num = 2
        // while(num < 100){
        //     if(num % 3 === 0){
        //         console.log(num)
        //     }
        //     num++
        // }
        //debugger断点，用于在死循环中使用

        //循环输出0-9，但是跳过7
        //continue ：只有遇到就不执行其代码块中后面的代码
        //代码执行，天道下一步（布尔表达式的判断）
        //如果第二步 还为 真，就继续执行 代码块的代码
        //方法一：
        // var num = -1;
        // while(num < 9){
        //     num++;
        //     if(num === 7){
        //         continue;
        //     }
        //     console.log(num);
        // }
        //方法二：
        //     var num = 0;
        //     while(num <= 9){
        //         if(num === 7){
        //             num++;
        //             continue;
        //         }
        //         console.log(num);
        //         num++;
        //     }

        //break 的执行逻辑： 和continue 的唯一区别是，遇到break，整个循环彻底终止

        // var  num = 0;
        // while(num < 10){
        //     if(num === 7){
        //         console.log('可以这样')
        //         break;
        //     }
        //     console.log(num)
        //     num++
        // }
    }

    {//du while
        // var num = false
        // do{
        //     console.log('我爱你')
        // }while(num)
    }

    {//for

        // for(1.声明变量 2.对变量进行逻辑判断 3.改变变量的值)
        // for(var i = 0; i < 10; i++){
        //     console.log(i)
        // }

        // 执行顺序：1  243243243243....   直到第二部返回值为  假  停止执行
        
        // for(var i = 0;i < 10; i++){
        //     if(i <= 5){
        //         console.log('123')
        //     }else if(i < 8){
        //         console.log('456')
        //     }else{
        //         console.log('789')
        //     }
        // }

        // for(var i = 0;i <= 9;i++){
        //     if(i == 7){
        //         continue;
        //     }
        //     console.log(i)
        // }

        // for(var i = 0;i < 100; i++){
        //     if(i % 3 ==0){
        //         console.log(i)
        //     }
        // }

    }
}
{//对象，数组
    // var obj = { key: value, key: value, ... }   ->   字典 :对象
    // var arr = [item, item, ...]; :数组
}
{//函数
    // 声明方法:
    //     方法一:声明式
    //         function fn(){

    //         }
    //     方法二:赋值式
    //         var fn = function(){

    //         }
    //return
    //return 的作用：将函数当中 某个 表示“返回” 出去，作为函数执行之后的 返回值
        //其后面可以放任何表达式，这个表达式的返回值就会作为函数执行的结果值（也叫做返回值）
    //特性：
        //在只要执行了 return ，其后的代码，就都不会被执行

    //2.arguments  是特殊关键字，不能用作变量，只能出现在函数里面
    //需求是：add这个函数里面可以放N个实参，add 把这个实参加到一起
    // function fn(){
    //     var num;
    //     arguments
    //     num = arguments[0] + arguments[4]
    //     console.log(num)
    // }
    // fn(1,2,3,4,5)
    // }
}
{//变量的提升

    //这是JS的一种缺陷，尽量不要使用
    // console.log(num)
    // var num = 1
    //执行本质：
        //1.var num；
        //2.console.log(num)
        //3.num = 1
}
{//函数的预解析
    //什么是预解析：在代码执行（从上往下执行之前），JS的解析器 -> 会先扫描一边代码
    //如果发现是声明式函数的话，就把函数直接解析一遍
    //所以，预解析的本质就是：但凡是声明式函数，无论在第几行声明;他永远会在代码之前，先被解析一遍
            //这就叫预解析
}
{//作用域 ：变量的作用区域/可以分为全局作用域，函数作用域
    //函数作用域中，变量的值如何确定
        //1.函数作用域中，如果有变量a，先看变量a是不是形参
            //如果是形参的话，形参a的值，有函数调用时，实参确定。
        //2.如果函数作用域中有变量a，而变量a不是形参
            //那么a得知回望外找，如果外部作用域 有同名变量
            //那么a的值,为外部同名变量的值

    // 函数作用域中 任何变量（不管是形参，还是声明的），都不会外暴露
    //总结：外界拿不到函数作用域内的变量
}
{//DOM
    //各个标签都是DOM
}
{//点击事件：基本原理：将函数绑定到DOM元素上

}
{//数组

    {//增
        // arr.push(5,45)   push :在数组尾部添加括号内的值
        //返回值：number ，表示的是length
        //push方法改变原有变量的值
    }
    {//删
        //arr.pop()
        //作用：删掉尾部的第一个元素
        //方法的 返回值：删掉的那个元素的 值
        //改变 变量 原来的值
    }
    {//开头增删
        //shift //删
        //unshift //增
    }
    {//数组的截取 - slice
        //变量不会改变 本身 的值
        //如果只有start -> 从arr[2]到数组的最后， 输出出来 arr.slice(2)
        //如果是（start，end）arr.slice(2,5) 从2到5
    }
    {//合并 concat
        //作用：将N个数组与 原数组合并到一起， 返回值为 一个新的数组：
        //contant 不改变变量本来的值
        //concat 的特性， 参数若是数组， 会把 数组的[]去掉，（只能去掉一层[]）
        // var arr1 = arr.concat()
    }
    {//删除特定下表元素 splice
        //总结：删除数组中某段元素，并可向删掉的元素的位置，再加入N个元素
        //第一个参数：start，表示从哪儿开始 截取
        //第二个参数：表示删除的个数
        //第三个参数：表示向 删除位置，加入新的元素
        //返回值：为删掉的元素
        //改变 变量本身的值，变量本身值剩下 删掉元素后，剩下的那些元素
    }
    {//join不改变变量本身的值
        //作用：将数组拼接成字符串，中间的分隔符决定了怎样拼接
        //var aa = arr.join(',')

    }
    {//indexof 
        //作用：返回搜索元素，所有数组当中的 index
        //若搜索数字不在数组当中，返回值为-1
    }
    {//lasyIndexof
        //恰好相反，从右向左搜索

    }
    {//includes
        // 数组中是否包括所填写数字
    }
    {//reverse 将数组中元素位置颠倒

    }
    {//sort 改变函数 本身 的值，同时返回排序之后的数组
        //a - b为升序
        //b - a为降序
        // var arr = [3,4,5,1,4,5,66,1,]
        // var result = arr.sort(function(a,b){
        //     return a - b;
        // })
        // console.log(result,arr);
        // var arr = [
        //     {age: 12},            {age: 13},
        //     {age: 3},
        //     {age: 42}
        // ]


    }

}
{//字符串

    // String.length  查看字符串的长度
    //s.[index]  以下标形式查看字符串的· 每个 字母
    //s.charAt[index] 作用等同于s.[index]
    //s.at(index) 相对比下多了可以填写负数的作用，-1，-2，为从后往前查找
    //s.slice(1,3) == s.substring(1,3) 截取一块字符串
    //s.split  字符串分割为数组
    //s.replace  替换搜索的字符串，但只是替换第一个

    // function returnLast(arr) {
    //     return arr.at(-1);
    //   }
      
    //   let invoiceRef = 'myinvoice01';
      
    //   console.log( returnLast(invoiceRef) );   

    //  var str = 'asddafasf'
    //  console.log(str.slice(1,5));
    {//字符串反转
        //  var str = 'strasdadsdadsad'
        //  var str1 = str.split("").reverse().join("")
        //  console.log(str1);
        // var str2 = ''
        // for(var i = str.length-1;i >= 0; i--){
        //     str2 += str[i]
        // }
        // console.log(str2);
    
    }
     
    
    {//常用方法

        //字母转大小写，str.toLowerCase,toUpperCase
        //静态方法 String.fromCharCode(97)
        //作用：将UTF-16的值， 转为 字符
        //console.log(String.fromCharCode(67));

    }

}

{//this
    // var arr = {
    //     name: '好大儿，常友好',
    //     say: function(){
    //         console.log('我的儿子',this.name)
    //     }
    // }
    // arr.say()
}
// console.log(Math.random(2))
{//Math
    //Math.PI
        //windiw 上的一个对象
        //但凡是 对象 它就有 属性 和 方法
        //Math.PI 为Π 为180度 2 * Math。PI -> 360度
        //PI 的值叫 弧度

    //Math.abs() 绝对值 absolute
    
    //Math.ceil()  将浮点数向上取整

    //Math.floor() 向下取整

    //Math.max  最大值  /  min  最小值

    //Math.pow(底数，指数) 求幂   2 ** 9

    //Math.random() 输出一个0 - 1的随机数 [0,1)

    //Math.round(浮点数) 返回一个四舍五入最接近的整数

    //练习：如何取 10 - 20 的随机数

    // Math.random（） * 10 + 10

}
{//date 
    //date 对象 能依次 get 出：年月日时分秒毫秒  
    // date.getFullYear 年
    // date.getMonth    月
    // date.getDate     日
    // date.getHours    时
    // date.getMinutes  分
    // date.getSeconds  秒
}